﻿<%@ WebHandler Language="C#" Class="LoadFileHandler" %>

using System;
using System.Web;

public class LoadFileHandler : IHttpHandler {
    
    public void ProcessRequest (HttpContext context) {
        context.Response.ContentType = "application/json";
        
        log4net.ILog log = log4net.LogManager.GetLogger("LogFile");
        string filename = HttpContext.Current.Request.Headers["X-File-Name"];
        System.IO.Stream stream = null;
        int contentLength = 32768;

        Iudicium.Archivos.LoadFileResponse result = new Iudicium.Archivos.LoadFileResponse();
        System.Web.Script.Serialization.JavaScriptSerializer js = new System.Web.Script.Serialization.JavaScriptSerializer();
        
        if (string.IsNullOrEmpty(filename) && HttpContext.Current.Request.Files.Count <= 0)
        {
            context.Response.Write(js.Serialize(result));
        }
        else
        {
            if (filename == null)
            {
                //This work for IE
                try
                {
                    HttpPostedFile uploadedFile = context.Request.Files[0];
                    filename = uploadedFile.FileName;
                    stream = uploadedFile.InputStream;
                    contentLength = uploadedFile.ContentLength;
                    
                }
                catch (Exception)
                {
                    context.Response.Write(js.Serialize(result));
                }
            }
            else
            {
                //This work for other browsers
                try
                {
                    stream = context.Request.InputStream;
                    contentLength = context.Request.ContentLength;
                }
                catch (Exception)
                {
                    context.Response.Write(js.Serialize(result));
                }
            }
            
            if(stream == null)
            {
                context.Response.Write(js.Serialize(result));
                return;
            }
            byte[] buffer = ReadFully(stream, contentLength);
            string storagePath = Iudicium.Configuracion.ConfiguracionIudicium.GetStoragePath() + "\\" + System.IO.Path.GetRandomFileName();
            try
            {
                // Create a file

                System.IO.FileStream newFile = new System.IO.FileStream(storagePath, System.IO.FileMode.Create);

                // Write data to the file

                newFile.Write(buffer, 0, buffer.Length);

                // Close file

                newFile.Close();
            }
            catch (Exception ex)
            {
                log.Error("No se pudo guardar el archivo en el disco duro",ex);
                context.Response.Write(js.Serialize(result));
                return;
            }
            int index = filename.LastIndexOf(".");
            string ext = filename.Substring(index, filename.Length  - index);
            Iudicium.Archivos.Archivo objArchivo = new Iudicium.Archivos.Archivo(0, filename, ext, storagePath, DateTime.Now, true);
            int archivoId = 0;
            try
            {
                archivoId = Iudicium.Archivos.CRN.ArchivoCRN.InsertarArchivo(objArchivo);
            }
            catch (Exception ex)
            {
                log.Error("Ocurrio un error al guardar el archivo", ex);
                context.Response.Write(js.Serialize(result));
                return;
            }
            result.ArchivoId = archivoId;
            result.Success = true;
            result.FileName = filename;
            context.Response.Write(js.Serialize(result));
        }
    }

    public static byte[] ReadFully(System.IO.Stream stream, int contentLength)
    {
        byte[] buffer = new byte[32768];
        stream.Seek(0, System.IO.SeekOrigin.Begin);
        using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
        {
            while (true)
            {
                int read = stream.Read(buffer, 0, buffer.Length);
                if (read <= 0)
                    return ms.ToArray();
                ms.Write(buffer, 0, read);
            }
        }
    }
 
    public bool IsReusable {
        get {
            return false;
        }
    }

}